type go/types.operand
106 uses
go/types (current package)
api.go#L440: x := operand{mode: value, typ: V}
api.go#L451: x := operand{mode: value, typ: V}
assignments.go#L20: func (check *Checker) assignment(x *operand, T Type, context string) {
assignments.go#L105: func (check *Checker) initConst(lhs *Const, x *operand) {
assignments.go#L136: func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
assignments.go#L167: func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
assignments.go#L203: var z operand
assignments.go#L222: var op operand
assignments.go#L242: func operandTypes(list []*operand) (res []Type) {
builtins.go#L20: func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
builtins.go#L44: var arg func(*operand, int) // TODO(gri) remove use of arg getter in favor of using xlist directly
builtins.go#L50: arg = func(x *operand, i int) { *x = *xlist[i] }
builtins.go#L108: alist := []operand{*x}
builtins.go#L137: var xlist []*operand
builtins.go#L143: var x operand
builtins.go#L259: var y operand
builtins.go#L292: toFloat := func(x *operand) {
builtins.go#L355: var y operand
builtins.go#L617: var y operand
builtins.go#L693: check.record(&operand{mode, selx, obj.Type(), nil, 0})
builtins.go#L744: var y operand
builtins.go#L785: var t operand
builtins.go#L827: func (check *Checker) applyTypeFunc(f func(Type) Type, x *operand, id builtinId) Type {
call.go#L19: func (check *Checker) funcInst(x *operand, ix *typeparams.IndexExpr) {
call.go#L97: func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
call.go#L244: func (check *Checker) exprList(elist []ast.Expr, allowCommaOk bool) (xlist []*operand, commaOk bool) {
call.go#L252: var x operand
call.go#L256: xlist = make([]*operand, t.Len())
call.go#L258: xlist[i] = &operand{mode: value, expr: e, typ: v.typ}
call.go#L264: xlist = []*operand{&x}
call.go#L266: x2 := &operand{mode: value, expr: e, typ: Typ[UntypedBool]}
call.go#L276: xlist = make([]*operand, len(elist))
call.go#L278: var x operand
call.go#L288: func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type, args []*operand, xlist []ast.Expr) (rsig *Signature) {
call.go#L432: func (check *Checker) selector(x *operand, e *ast.SelectorExpr, def *Named) {
call.go#L731: var x operand
call.go#L746: var x operand
check.go#L403: func (check *Checker) record(x *operand) {
conversions.go#L16: func (check *Checker) conversion(x *operand, T Type) {
conversions.go#L129: func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
decl.go#L447: var x operand
decl.go#L490: var x operand
errors.go#L82: case operand:
errors.go#L84: case *operand:
errors.go#L287: case *operand:
eval.go#L94: var x operand
expr.go#L74: func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
expr.go#L90: func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
expr.go#L157: func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
expr.go#L417: func (check *Checker) representable(x *operand, typ *Basic) {
expr.go#L432: func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, errorCode) {
expr.go#L455: func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) {
expr.go#L585: c := operand{old.mode, x, old.typ, old.val, 0}
expr.go#L605: func (check *Checker) convertUntyped(x *operand, target Type) {
expr.go#L632: func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, errorCode) {
expr.go#L732: func (check *Checker) comparison(x, y *operand, op token.Token, switchCase bool) {
expr.go#L896: func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
expr.go#L1062: func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
expr.go#L1063: var y operand
expr.go#L1083: canMix := func(x, y *operand) bool {
expr.go#L1198: func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type, allowGeneric bool) exprKind {
expr.go#L1221: func (check *Checker) nonGeneric(x *operand) {
expr.go#L1246: func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
expr.go#L1684: func (check *Checker) typeAssertion(e ast.Expr, x *operand, T Type, typeSwitch bool) {
expr.go#L1704: func (check *Checker) expr(x *operand, e ast.Expr) {
expr.go#L1711: func (check *Checker) multiExpr(x *operand, e ast.Expr) {
expr.go#L1720: func (check *Checker) exprWithHint(x *operand, e ast.Expr, hint Type) {
expr.go#L1732: func (check *Checker) exprOrType(x *operand, e ast.Expr, allowGeneric bool) {
expr.go#L1740: func (check *Checker) exclude(x *operand, modeset uint) {
expr.go#L1767: func (check *Checker) singleValue(x *operand) {
index.go#L18: func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst bool) {
index.go#L94: var key operand
index.go#L168: var k operand
index.go#L209: func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
index.go#L351: var x operand
index.go#L376: func (check *Checker) isValidIndex(x *operand, code errorCode, what string, allowNegative bool) bool {
index.go#L451: var x operand
infer.go#L32: func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (result []Type) {
infer.go#L152: args2 := make([]*operand, m)
infer.go#L207: errorf := func(kind string, tpar, targ Type, arg *operand) {
operand.go#L53: type operand struct {
operand.go#L64: func (x *operand) Pos() token.Pos {
operand.go#L106: func operandString(x *operand, qf Qualifier) string {
operand.go#L190: func (x *operand) String() string {
operand.go#L195: func (x *operand) setConst(tok token.Token, lit string) {
operand.go#L224: func (x *operand) isNil() bool {
operand.go#L234: func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, errorCode) {
stmt.go#L174: var x operand
stmt.go#L237: func (check *Checker) caseValues(x *operand, values []ast.Expr, seen valueMap) {
stmt.go#L240: var v operand
stmt.go#L285: func (check *Checker) caseTypes(x *operand, types []ast.Expr, seen map[Type]ast.Expr) (T Type) {
stmt.go#L286: var dummy operand
stmt.go#L394: var x operand
stmt.go#L415: var ch, val operand
stmt.go#L449: var x operand
stmt.go#L491: var x operand
stmt.go#L566: var x operand
stmt.go#L589: var x operand
stmt.go#L682: var x operand
stmt.go#L688: var sx *operand // switch expression against which cases are compared against; nil if invalid
stmt.go#L804: var x operand
stmt.go#L826: var x operand
typexpr.go#L22: func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) {
typexpr.go#L243: var x operand
typexpr.go#L260: var x operand
typexpr.go#L514: var x operand